Les matrices numpy (numpy arrays)

Vous êtes familiers avec les listes en Python. Les "arrays" de numpy sont des listes ... ou des listes de listes ... ou des listes de listes de listes... Ce sont essentiellement (sauf pour des différences mineures) des matrices.

On peut utiliser des listes Python pour initialiser un "array" de numpy.



In [1]:

    
import numpy as np  # Presque tous les programmeurs utilisent l'abbréviation np

ma_liste = [1, 2, 3, 4, 5]
array1 = np.array(ma_liste)

print("ma liste:", ma_liste)
print("objet numpy: ", array1)









    



ma liste: [1, 2, 3, 4, 5]
objet numpy:  [1 2 3 4 5]

Au lieu d'imprimer l'objet numpy, on peut voir sa représentation directement



In [2]:

    
array1









    Out[2]:





array([1, 2, 3, 4, 5])

Créons une deuxième liste ainsi qu'une liste de listes



In [3]:

    
ma_liste2 = [10, 20, 30, 40, 50]
mes_listes = [ma_liste, ma_liste2]
print("mes listes: \n", mes_listes)
print("-"*40)

matrice = np.array(mes_listes)
print("La matrice: \n", matrice)
print("-"*40)
print("Représentation de la matrice:")
matrice   # pour voir sa représentation









    



mes listes: 
 [[1, 2, 3, 4, 5], [10, 20, 30, 40, 50]]
----------------------------------------
La matrice: 
 [[ 1  2  3  4  5]
 [10 20 30 40 50]]
----------------------------------------
Représentation de la matrice:






    Out[3]:





array([[ 1,  2,  3,  4,  5],
       [10, 20, 30, 40, 50]])

Nous avons donc une matrice avec 2 lignes et 5 colonnes, dont les éléments sont des entiers.



In [4]:

    
print("shape = ", matrice.shape)     # information sur nombre de lignes et colonnes
print("type = ", matrice.dtype)     # information sur le contenu









    



shape =  (2, 5)
type =  int32

On peut automatiquement créer des matrices particulières, soient remplies avec des zéros, des 1, ou la matrice identité (qui est une matrice carrée par définition.



In [10]:

    
print(np.zeros(4))
print('-'*40)

print(np.zeros([3,3]))
print('-'*40)

print(np.ones([3,2]))
print('-'*40)

print(np.eye(4))    # matrice identité









    



[ 0.  0.  0.  0.]
----------------------------------------
[[ 0.  0.  0.]
 [ 0.  0.  0.]
 [ 0.  0.  0.]]
----------------------------------------
[[ 1.  1.]
 [ 1.  1.]
 [ 1.  1.]]
----------------------------------------
[[ 1.  0.  0.  0.]
 [ 0.  1.  0.  0.]
 [ 0.  0.  1.  0.]
 [ 0.  0.  0.  1.]]

Numpy inclut une généralisation de la fonction "range" the Python, mais permettant des valeurs non-entières.



In [6]:

    
np.arange(1, 5, 0.2)









    Out[6]:





array([ 1. ,  1.2,  1.4,  1.6,  1.8,  2. ,  2.2,  2.4,  2.6,  2.8,  3. ,
        3.2,  3.4,  3.6,  3.8,  4. ,  4.2,  4.4,  4.6,  4.8])

Opérations élémentaires sur les matrices (arrays) numpy

Par défaut, les opérations sont faites sur chaque élément de la matrice. Nous allons démontrer ceci en créant deux matrices de la même taille (même nombre de lignes et de colonnes) et en faisant diverses opérations.

Nous commençons avec des opérations sur une seule matrice.



In [7]:

    
mat1 = np.array([ [1, 2, 3], [4, 5, 6]])

print(3 * mat1)
print("-"*40)

print(mat1 / 2)
print("-"*40)

print(1 / mat1)
print("-"*40)

print(mat1 % 3)
print("-"*40)

print(mat1 + 20)
print("-"*40)









    



[[ 3  6  9]
 [12 15 18]]
----------------------------------------
[[ 0.5  1.   1.5]
 [ 2.   2.5  3. ]]
----------------------------------------
[[ 1.          0.5         0.33333333]
 [ 0.25        0.2         0.16666667]]
----------------------------------------
[[1 2 0]
 [1 2 0]]
----------------------------------------
[[21 22 23]
 [24 25 26]]
----------------------------------------

Nous considérons maintenant des opérations avec deux matrices.



In [8]:

    
mat2 = np.array([ [11, 12, 13], [14, 15, 16]])

print(mat1 + mat2)
print("-"*40)

print(mat2 - mat1)
print("-"*40)

print(mat1 * mat1)   # IMPORTANT: ceci n'est PAS la multiplication normale de matrices









    



[[12 14 16]
 [18 20 22]]
----------------------------------------
[[10 10 10]
 [10 10 10]]
----------------------------------------
[[ 1  4  9]
 [16 25 36]]

Si on essaie de faire de telles opérations sur des matrices de taille différente, cela ne fonctionne pas.



In [9]:

    
mat3 = np.array([[1, 2], [3, 4]])
mat3 * mat1









    



---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-9-b12f57d37ee7> in <module>()
      1 mat3 = np.array([[1, 2], [3, 4]])
----> 2 mat3 * mat1

ValueError: operands could not be broadcast together with shapes (2,2) (2,3)